const fs = require('fs');
const path = require('path');

// 读取Vue文件
const filePath = path.resolve(__dirname, 'components/agency-info/agency-info.vue');
const content = fs.readFileSync(filePath, 'utf-8');

// 提取script部分
const scriptRegex = /<script>([\s\S]*?)<\/script>/;
const scriptMatch = content.match(scriptRegex);
const script = scriptMatch ? scriptMatch[1] : '';

console.log('===== 详细检查脚本语法 =====');

// 将script内容按行分割
const lines = script.split('\n');
console.log(`脚本共有 ${lines.length} 行`);

// 尝试找到组件定义的开始和结束位置
const exportDefaultLine = lines.findIndex(line => line.trim().includes('export default {'));
console.log(`'export default {' 位于第 ${exportDefaultLine + 1} 行`);

// 尝试手动解析组件对象，寻找潜在的语法错误
let braceCount = 0;
let inComment = false;
let inString = false;
let currentStringChar = '';

for (let i = 0; i < lines.length; i++) {
  const line = lines[i];
  let lineTrimmed = line.trim();
  
  // 跳过注释行
  if (lineTrimmed.startsWith('//') || lineTrimmed.startsWith('/*') && lineTrimmed.endsWith('*/')) {
    continue;
  }
  
  // 检查该行的括号平衡
  for (let j = 0; j < line.length; j++) {
    const char = line[j];
    
    // 检查字符串
    if ((char === '"' || char === "'") && line[j-1] !== '\\') {
      if (inString) {
        if (char === currentStringChar) {
          inString = false;
        }
      } else {
        inString = true;
        currentStringChar = char;
      }
      continue;
    }
    
    // 检查注释
    if (!inString && !inComment && char === '/' && line[j+1] === '*') {
      inComment = true;
      continue;
    }
    if (!inString && inComment && char === '*' && line[j+1] === '/') {
      inComment = false;
      continue;
    }
    
    // 只在不在字符串和注释中的情况下检查括号
    if (!inString && !inComment) {
      if (char === '{') {
        braceCount++;
      } else if (char === '}') {
        braceCount--;
      }
    }
  }
  
  // 检查括号是否平衡
  if (braceCount < 0) {
    console.error(`第 ${i + 1} 行: 括号不平衡，有多余的右括号`);
    console.log(`该行内容: ${line}`);
    process.exit(1);
  }
  
  // 检查常见的语法错误模式
  if (lineTrimmed.includes(':') && !lineTrimmed.includes('//') && !lineTrimmed.includes('/*')) {
    // 简单检查对象属性格式
    const parts = lineTrimmed.split(':').map(part => part.trim());
    if (parts.length > 1 && !parts[0].includes('function') && 
        !parts[0].includes('(') && !parts[0].includes('{') && 
        !parts[0].includes('}') && !parts[0].startsWith('//') && 
        !parts[0].endsWith(',')) {
      // 检查属性名是否正确
      if (!/^['"A-Za-z_$][A-Za-z0-9_$'"\.]*$/.test(parts[0]) && 
          !parts[0].includes('[')) {
        console.warn(`第 ${i + 1} 行: 可能的属性格式问题`);
        console.log(`该行内容: ${line}`);
      }
      
      // 检查属性值是否以逗号结尾
      if (!lineTrimmed.endsWith(',') && !lineTrimmed.includes('{') && 
          !lineTrimmed.includes('}') && !lineTrimmed.endsWith(';') && 
          !lineTrimmed.includes('if') && !lineTrimmed.includes('for') && 
          !lineTrimmed.includes('function') && !lineTrimmed.includes('=>')) {
        // 检查下一行是否是新的属性或结束括号
        const nextLineIndex = i + 1;
        if (nextLineIndex < lines.length) {
          const nextLine = lines[nextLineIndex].trim();
          if (nextLine && !nextLine.startsWith('//') && 
              !nextLine.startsWith('/*') && !nextLine.startsWith('}') && 
              !nextLine.startsWith(',')) {
            console.warn(`第 ${i + 1} 行: 对象属性后可能缺少逗号`);
            console.log(`该行内容: ${line}`);
            console.log(`下一行内容: ${nextLine}`);
          }
        }
      }
    }
  }
}

// 最终检查括号平衡
if (braceCount !== 0) {
  console.error(`括号不平衡: 多了 ${braceCount > 0 ? '左' : '右'} 括号 ${Math.abs(braceCount)} 个`);
} else {
  console.log('括号检查通过！');
}

console.log('\n尝试使用更严格的方法检查...');

// 尝试找到组件定义的具体内容
const exportStart = script.indexOf('export default {');
if (exportStart !== -1) {
  // 尝试从export default开始，构建一个简化的组件对象
  let componentBody = script.substring(exportStart + 15).trim();
  
  // 手动处理，寻找匹配的结束括号
  let depth = 0;
  let endIndex = -1;
  
  for (let i = 0; i < componentBody.length; i++) {
    if (componentBody[i] === '{') depth++;
    else if (componentBody[i] === '}') depth--;
    
    if (depth === -1) {
      endIndex = i;
      break;
    }
  }
  
  if (endIndex !== -1) {
    componentBody = componentBody.substring(0, endIndex).trim();
    
    // 尝试用不同的方式解析这个对象
    try {
      // 尝试方式1: 直接作为对象解析
      new Function(`return {${componentBody}}`);
      console.log('方式1检查通过！');
    } catch (error1) {
      console.error('方式1解析错误:', error1.message);
      
      // 尝试方式2: 作为函数体解析
      try {
        new Function(componentBody);
        console.log('方式2检查通过！');
      } catch (error2) {
        console.error('方式2解析错误:', error2.message);
        
        // 尝试找出可能的错误位置
        console.log('\n尝试找出可能的错误位置...');
        
        // 将componentBody分成更小的部分，逐步检查
        const parts = componentBody.split(',\n');
        let cumulative = '';
        
        for (let i = 0; i < parts.length; i++) {
          try {
            cumulative += (i > 0 ? ',\n' : '') + parts[i];
            new Function(`return {${cumulative}}`);
          } catch (partError) {
            console.error(`在第 ${i+1} 个部分发现错误:`, partError.message);
            console.log(`该部分内容: ${parts[i].substring(0, 100)}...`);
            break;
          }
        }
      }
    }
  } else {
    console.error('找不到匹配的结束括号');
  }
} else {
  console.error('找不到export default定义');
}

console.log('\n详细检查完成！');